{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d7bb5b4c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch            : 1.10.1\n",
      "pytorch_lightning: 1.5.1\n",
      "torchmetrics     : 0.6.2\n",
      "matplotlib       : 3.3.4\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%load_ext watermark\n",
    "%watermark -p torch,pytorch_lightning,torchmetrics,matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07125f0f",
   "metadata": {},
   "source": [
    "The three extensions below are optional, for more information, see\n",
    "- `watermark`:  https://github.com/rasbt/watermark\n",
    "- `pycodestyle_magic`: https://github.com/mattijn/pycodestyle_magic\n",
    "- `nb_black`: https://github.com/dnanhkhoa/nb_black"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "864e1616",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext pycodestyle_magic\n",
    "%flake8_on --ignore W291,W293,E703,E402 --max_line_length=100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9d8a3c40",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 3;\n",
       "                var nbb_unformatted_code = \"%load_ext nb_black\";\n",
       "                var nbb_formatted_code = \"%load_ext nb_black\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%load_ext nb_black"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01859a43",
   "metadata": {},
   "source": [
    "<a href=\"https://pytorch.org\"><img src=\"https://raw.githubusercontent.com/pytorch/pytorch/master/docs/source/_static/img/pytorch-logo-dark.svg\" width=\"90\"/></a> &nbsp; &nbsp;&nbsp;&nbsp;<a href=\"https://www.pytorchlightning.ai\"><img src=\"https://raw.githubusercontent.com/PyTorchLightning/pytorch-lightning/master/docs/source/_static/images/logo.svg\" width=\"150\"/></a>\n",
    "\n",
    "# Multilayer Perceptron with Dropout trained on MNIST"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9315c0f1",
   "metadata": {},
   "source": [
    "A simple multilayer perceptron [1][2] with Dropout [3][4][5] trained on MNIST [6].\n",
    "\n",
    "### References\n",
    "\n",
    "- [1] https://en.wikipedia.org/wiki/Multilayer_perceptron\n",
    "- [2] L9.1 Multilayer Perceptron Architecture (24:24): https://www.youtube.com/watch?v=IUylp47hNA0\n",
    "- [3] https://en.wikipedia.org/wiki/Dilution_(neural_networks)\n",
    "- [4] L10.5.1 The Main Concept Behind Dropout (11:07): https://www.youtube.com/watch?v=IHrZNBsgtwU\n",
    "- [5] Dropout: a simple way to prevent neural networks from overfitting, https://jmlr.org/papers/v15/srivastava14a.html\n",
    "- [6] https://en.wikipedia.org/wiki/MNIST_database"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2da793e7",
   "metadata": {},
   "source": [
    "## General settings and hyperparameters"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41acc842",
   "metadata": {},
   "source": [
    "- Here, we specify some general hyperparameter values and general settings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c4c24c79",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 4;\n",
       "                var nbb_unformatted_code = \"HIDDEN_UNITS = (128, 256)\\nBATCH_SIZE = 256\\nNUM_EPOCHS = 10\\nLEARNING_RATE = 0.005\\nNUM_WORKERS = 4\\nDROPOUT_PROBA = 0.5\";\n",
       "                var nbb_formatted_code = \"HIDDEN_UNITS = (128, 256)\\nBATCH_SIZE = 256\\nNUM_EPOCHS = 10\\nLEARNING_RATE = 0.005\\nNUM_WORKERS = 4\\nDROPOUT_PROBA = 0.5\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "HIDDEN_UNITS = (128, 256)\n",
    "BATCH_SIZE = 256\n",
    "NUM_EPOCHS = 10\n",
    "LEARNING_RATE = 0.005\n",
    "NUM_WORKERS = 4\n",
    "DROPOUT_PROBA = 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5a41296",
   "metadata": {},
   "source": [
    "- Note that using multiple workers can sometimes cause issues with too many open files in PyTorch for small datasets. If we have problems with the data loader later, try setting `NUM_WORKERS = 0` and reload the notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d72e878",
   "metadata": {},
   "source": [
    "## Implementing a Neural Network using PyTorch Lightning's `LightningModule`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d657971",
   "metadata": {},
   "source": [
    "- In this section, we set up the main model architecture using the `LightningModule` from PyTorch Lightning.\n",
    "- In essence, `LightningModule` is a wrapper around a PyTorch module.\n",
    "- We start with defining our neural network model in pure PyTorch, and then we use it in the `LightningModule` to get all the extra benefits that PyTorch Lightning provides."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "48a7733d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 5;\n",
       "                var nbb_unformatted_code = \"import torch\\nimport torch.nn.functional as F\\n\\n\\n# Regular PyTorch Module\\nclass PyTorchModel(torch.nn.Module):\\n    def __init__(self, input_size, hidden_units, dropout_proba, num_classes):\\n        super().__init__()\\n        \\n        self.dropout_proba = dropout_proba\\n        # Initialize MLP layers\\n        all_layers = []\\n        for hidden_unit in hidden_units:\\n            layer = torch.nn.Linear(input_size, hidden_unit)\\n            all_layers.append(layer)\\n            all_layers.append(torch.nn.ReLU())\\n            all_layers.append(torch.nn.Dropout(dropout_proba))\\n            input_size = hidden_unit\\n\\n        output_layer = torch.nn.Linear(\\n            in_features=hidden_units[-1],\\n            out_features=num_classes)\\n\\n        all_layers.append(output_layer)\\n        self.layers = torch.nn.Sequential(*all_layers)\\n\\n    def forward(self, x):\\n        x = torch.flatten(x, start_dim=1)  # to make it work for image inputs\\n        x = self.layers(x)\\n        return x  # x are the model's logits\";\n",
       "                var nbb_formatted_code = \"import torch\\nimport torch.nn.functional as F\\n\\n\\n# Regular PyTorch Module\\nclass PyTorchModel(torch.nn.Module):\\n    def __init__(self, input_size, hidden_units, dropout_proba, num_classes):\\n        super().__init__()\\n\\n        self.dropout_proba = dropout_proba\\n        # Initialize MLP layers\\n        all_layers = []\\n        for hidden_unit in hidden_units:\\n            layer = torch.nn.Linear(input_size, hidden_unit)\\n            all_layers.append(layer)\\n            all_layers.append(torch.nn.ReLU())\\n            all_layers.append(torch.nn.Dropout(dropout_proba))\\n            input_size = hidden_unit\\n\\n        output_layer = torch.nn.Linear(\\n            in_features=hidden_units[-1], out_features=num_classes\\n        )\\n\\n        all_layers.append(output_layer)\\n        self.layers = torch.nn.Sequential(*all_layers)\\n\\n    def forward(self, x):\\n        x = torch.flatten(x, start_dim=1)  # to make it work for image inputs\\n        x = self.layers(x)\\n        return x  # x are the model's logits\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "# Regular PyTorch Module\n",
    "class PyTorchModel(torch.nn.Module):\n",
    "    def __init__(self, input_size, hidden_units, dropout_proba, num_classes):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.dropout_proba = dropout_proba\n",
    "        # Initialize MLP layers\n",
    "        all_layers = []\n",
    "        for hidden_unit in hidden_units:\n",
    "            layer = torch.nn.Linear(input_size, hidden_unit)\n",
    "            all_layers.append(layer)\n",
    "            all_layers.append(torch.nn.ReLU())\n",
    "            all_layers.append(torch.nn.Dropout(dropout_proba))\n",
    "            input_size = hidden_unit\n",
    "\n",
    "        output_layer = torch.nn.Linear(\n",
    "            in_features=hidden_units[-1],\n",
    "            out_features=num_classes)\n",
    "\n",
    "        all_layers.append(output_layer)\n",
    "        self.layers = torch.nn.Sequential(*all_layers)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = torch.flatten(x, start_dim=1)  # to make it work for image inputs\n",
    "        x = self.layers(x)\n",
    "        return x  # x are the model's logits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0ceb58d3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 6;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/lightningmodule_classifier_basic.py\\nimport pytorch_lightning as pl\\nimport torchmetrics\\n\\n\\n# LightningModule that receives a PyTorch model as input\\nclass LightningModel(pl.LightningModule):\\n    def __init__(self, model, learning_rate):\\n        super().__init__()\\n\\n        self.learning_rate = learning_rate\\n        # The inherited PyTorch module\\n        self.model = model\\n        if hasattr(model, \\\"dropout_proba\\\"):\\n            self.dropout_proba = model.dropout_proba\\n\\n        # Save settings and hyperparameters to the log directory\\n        # but skip the model parameters\\n        self.save_hyperparameters(ignore=[\\\"model\\\"])\\n\\n        # Set up attributes for computing the accuracy\\n        self.train_acc = torchmetrics.Accuracy()\\n        self.valid_acc = torchmetrics.Accuracy()\\n        self.test_acc = torchmetrics.Accuracy()\\n\\n    # Defining the forward method is only necessary\\n    # if you want to use a Trainer's .predict() method (optional)\\n    def forward(self, x):\\n        return self.model(x)\\n\\n    # A common forward step to compute the loss and labels\\n    # this is used for training, validation, and testing below\\n    def _shared_step(self, batch):\\n        features, true_labels = batch\\n        logits = self(features)\\n        loss = torch.nn.functional.cross_entropy(logits, true_labels)\\n        predicted_labels = torch.argmax(logits, dim=1)\\n\\n        return loss, true_labels, predicted_labels\\n\\n    def training_step(self, batch, batch_idx):\\n        loss, true_labels, predicted_labels = self._shared_step(batch)\\n        self.log(\\\"train_loss\\\", loss)\\n\\n        # Do another forward pass in .eval() mode to compute accuracy\\n        # while accountingfor Dropout, BatchNorm etc. behavior\\n        # during evaluation (inference)\\n        self.model.eval()\\n        with torch.no_grad():\\n            _, true_labels, predicted_labels = self._shared_step(batch)\\n        self.train_acc(predicted_labels, true_labels)\\n        self.log(\\\"train_acc\\\", self.train_acc, on_epoch=True, on_step=False)\\n        self.model.train()\\n\\n        return loss  # this is passed to the optimzer for training\\n\\n    def validation_step(self, batch, batch_idx):\\n        loss, true_labels, predicted_labels = self._shared_step(batch)\\n        self.log(\\\"valid_loss\\\", loss)\\n        self.valid_acc(predicted_labels, true_labels)\\n        self.log(\\n            \\\"valid_acc\\\",\\n            self.valid_acc,\\n            on_epoch=True,\\n            on_step=False,\\n            prog_bar=True,\\n        )\\n\\n    def test_step(self, batch, batch_idx):\\n        loss, true_labels, predicted_labels = self._shared_step(batch)\\n        self.test_acc(predicted_labels, true_labels)\\n        self.log(\\\"test_acc\\\", self.test_acc, on_epoch=True, on_step=False)\\n\\n    def configure_optimizers(self):\\n        optimizer = torch.optim.Adam(self.parameters(), lr=self.learning_rate)\\n        return optimizer\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/lightningmodule_classifier_basic.py\\nimport pytorch_lightning as pl\\nimport torchmetrics\\n\\n\\n# LightningModule that receives a PyTorch model as input\\nclass LightningModel(pl.LightningModule):\\n    def __init__(self, model, learning_rate):\\n        super().__init__()\\n\\n        self.learning_rate = learning_rate\\n        # The inherited PyTorch module\\n        self.model = model\\n        if hasattr(model, \\\"dropout_proba\\\"):\\n            self.dropout_proba = model.dropout_proba\\n\\n        # Save settings and hyperparameters to the log directory\\n        # but skip the model parameters\\n        self.save_hyperparameters(ignore=[\\\"model\\\"])\\n\\n        # Set up attributes for computing the accuracy\\n        self.train_acc = torchmetrics.Accuracy()\\n        self.valid_acc = torchmetrics.Accuracy()\\n        self.test_acc = torchmetrics.Accuracy()\\n\\n    # Defining the forward method is only necessary\\n    # if you want to use a Trainer's .predict() method (optional)\\n    def forward(self, x):\\n        return self.model(x)\\n\\n    # A common forward step to compute the loss and labels\\n    # this is used for training, validation, and testing below\\n    def _shared_step(self, batch):\\n        features, true_labels = batch\\n        logits = self(features)\\n        loss = torch.nn.functional.cross_entropy(logits, true_labels)\\n        predicted_labels = torch.argmax(logits, dim=1)\\n\\n        return loss, true_labels, predicted_labels\\n\\n    def training_step(self, batch, batch_idx):\\n        loss, true_labels, predicted_labels = self._shared_step(batch)\\n        self.log(\\\"train_loss\\\", loss)\\n\\n        # Do another forward pass in .eval() mode to compute accuracy\\n        # while accountingfor Dropout, BatchNorm etc. behavior\\n        # during evaluation (inference)\\n        self.model.eval()\\n        with torch.no_grad():\\n            _, true_labels, predicted_labels = self._shared_step(batch)\\n        self.train_acc(predicted_labels, true_labels)\\n        self.log(\\\"train_acc\\\", self.train_acc, on_epoch=True, on_step=False)\\n        self.model.train()\\n\\n        return loss  # this is passed to the optimzer for training\\n\\n    def validation_step(self, batch, batch_idx):\\n        loss, true_labels, predicted_labels = self._shared_step(batch)\\n        self.log(\\\"valid_loss\\\", loss)\\n        self.valid_acc(predicted_labels, true_labels)\\n        self.log(\\n            \\\"valid_acc\\\",\\n            self.valid_acc,\\n            on_epoch=True,\\n            on_step=False,\\n            prog_bar=True,\\n        )\\n\\n    def test_step(self, batch, batch_idx):\\n        loss, true_labels, predicted_labels = self._shared_step(batch)\\n        self.test_acc(predicted_labels, true_labels)\\n        self.log(\\\"test_acc\\\", self.test_acc, on_epoch=True, on_step=False)\\n\\n    def configure_optimizers(self):\\n        optimizer = torch.optim.Adam(self.parameters(), lr=self.learning_rate)\\n        return optimizer\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_lightningmodule/lightningmodule_classifier_basic.py\n",
    "import pytorch_lightning as pl\n",
    "import torchmetrics\n",
    "\n",
    "\n",
    "# LightningModule that receives a PyTorch model as input\n",
    "class LightningModel(pl.LightningModule):\n",
    "    def __init__(self, model, learning_rate):\n",
    "        super().__init__()\n",
    "\n",
    "        self.learning_rate = learning_rate\n",
    "        # The inherited PyTorch module\n",
    "        self.model = model\n",
    "        if hasattr(model, \"dropout_proba\"):\n",
    "            self.dropout_proba = model.dropout_proba\n",
    "\n",
    "        # Save settings and hyperparameters to the log directory\n",
    "        # but skip the model parameters\n",
    "        self.save_hyperparameters(ignore=[\"model\"])\n",
    "\n",
    "        # Set up attributes for computing the accuracy\n",
    "        self.train_acc = torchmetrics.Accuracy()\n",
    "        self.valid_acc = torchmetrics.Accuracy()\n",
    "        self.test_acc = torchmetrics.Accuracy()\n",
    "\n",
    "    # Defining the forward method is only necessary\n",
    "    # if you want to use a Trainer's .predict() method (optional)\n",
    "    def forward(self, x):\n",
    "        return self.model(x)\n",
    "\n",
    "    # A common forward step to compute the loss and labels\n",
    "    # this is used for training, validation, and testing below\n",
    "    def _shared_step(self, batch):\n",
    "        features, true_labels = batch\n",
    "        logits = self(features)\n",
    "        loss = torch.nn.functional.cross_entropy(logits, true_labels)\n",
    "        predicted_labels = torch.argmax(logits, dim=1)\n",
    "\n",
    "        return loss, true_labels, predicted_labels\n",
    "\n",
    "    def training_step(self, batch, batch_idx):\n",
    "        loss, true_labels, predicted_labels = self._shared_step(batch)\n",
    "        self.log(\"train_loss\", loss)\n",
    "\n",
    "        # Do another forward pass in .eval() mode to compute accuracy\n",
    "        # while accountingfor Dropout, BatchNorm etc. behavior\n",
    "        # during evaluation (inference)\n",
    "        self.model.eval()\n",
    "        with torch.no_grad():\n",
    "            _, true_labels, predicted_labels = self._shared_step(batch)\n",
    "        self.train_acc(predicted_labels, true_labels)\n",
    "        self.log(\"train_acc\", self.train_acc, on_epoch=True, on_step=False)\n",
    "        self.model.train()\n",
    "\n",
    "        return loss  # this is passed to the optimzer for training\n",
    "\n",
    "    def validation_step(self, batch, batch_idx):\n",
    "        loss, true_labels, predicted_labels = self._shared_step(batch)\n",
    "        self.log(\"valid_loss\", loss)\n",
    "        self.valid_acc(predicted_labels, true_labels)\n",
    "        self.log(\n",
    "            \"valid_acc\",\n",
    "            self.valid_acc,\n",
    "            on_epoch=True,\n",
    "            on_step=False,\n",
    "            prog_bar=True,\n",
    "        )\n",
    "\n",
    "    def test_step(self, batch, batch_idx):\n",
    "        loss, true_labels, predicted_labels = self._shared_step(batch)\n",
    "        self.test_acc(predicted_labels, true_labels)\n",
    "        self.log(\"test_acc\", self.test_acc, on_epoch=True, on_step=False)\n",
    "\n",
    "    def configure_optimizers(self):\n",
    "        optimizer = torch.optim.Adam(self.parameters(), lr=self.learning_rate)\n",
    "        return optimizer\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c708125",
   "metadata": {},
   "source": [
    "## Setting up the dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70effd61",
   "metadata": {},
   "source": [
    "- In this section, we are going to set up our dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cd9d8d7",
   "metadata": {},
   "source": [
    "### Inspecting the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c006d71b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Training label distribution:\n",
      "\n",
      "Test label distribution:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[(0, 980),\n",
       " (1, 1135),\n",
       " (2, 1032),\n",
       " (3, 1010),\n",
       " (4, 982),\n",
       " (5, 892),\n",
       " (6, 958),\n",
       " (7, 1028),\n",
       " (8, 974),\n",
       " (9, 1009)]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 7;\n",
       "                var nbb_unformatted_code = \"# %load ../code_dataset/dataset_mnist_check.py\\nfrom collections import Counter\\nfrom torchvision import datasets\\nfrom torchvision import transforms\\nfrom torch.utils.data import DataLoader\\n\\n\\ntrain_dataset = datasets.MNIST(\\n    root=\\\"./data\\\", train=True, transform=transforms.ToTensor(), download=True\\n)\\n\\ntrain_loader = DataLoader(\\n    dataset=train_dataset,\\n    batch_size=BATCH_SIZE,\\n    num_workers=NUM_WORKERS,\\n    drop_last=True,\\n    shuffle=True,\\n)\\n\\ntest_dataset = datasets.MNIST(\\n    root=\\\"./data\\\", train=False, transform=transforms.ToTensor()\\n)\\n\\ntest_loader = DataLoader(\\n    dataset=test_dataset,\\n    batch_size=BATCH_SIZE,\\n    num_workers=NUM_WORKERS,\\n    drop_last=False,\\n    shuffle=False,\\n)\\n\\ntrain_counter = Counter()\\nfor images, labels in train_loader:\\n    train_counter.update(labels.tolist())\\n\\ntest_counter = Counter()\\nfor images, labels in test_loader:\\n    test_counter.update(labels.tolist())\\n\\nprint(\\\"\\\\nTraining label distribution:\\\")\\nsorted(train_counter.items())\\n\\nprint(\\\"\\\\nTest label distribution:\\\")\\nsorted(test_counter.items())\";\n",
       "                var nbb_formatted_code = \"# %load ../code_dataset/dataset_mnist_check.py\\nfrom collections import Counter\\nfrom torchvision import datasets\\nfrom torchvision import transforms\\nfrom torch.utils.data import DataLoader\\n\\n\\ntrain_dataset = datasets.MNIST(\\n    root=\\\"./data\\\", train=True, transform=transforms.ToTensor(), download=True\\n)\\n\\ntrain_loader = DataLoader(\\n    dataset=train_dataset,\\n    batch_size=BATCH_SIZE,\\n    num_workers=NUM_WORKERS,\\n    drop_last=True,\\n    shuffle=True,\\n)\\n\\ntest_dataset = datasets.MNIST(\\n    root=\\\"./data\\\", train=False, transform=transforms.ToTensor()\\n)\\n\\ntest_loader = DataLoader(\\n    dataset=test_dataset,\\n    batch_size=BATCH_SIZE,\\n    num_workers=NUM_WORKERS,\\n    drop_last=False,\\n    shuffle=False,\\n)\\n\\ntrain_counter = Counter()\\nfor images, labels in train_loader:\\n    train_counter.update(labels.tolist())\\n\\ntest_counter = Counter()\\nfor images, labels in test_loader:\\n    test_counter.update(labels.tolist())\\n\\nprint(\\\"\\\\nTraining label distribution:\\\")\\nsorted(train_counter.items())\\n\\nprint(\\\"\\\\nTest label distribution:\\\")\\nsorted(test_counter.items())\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_dataset/dataset_mnist_check.py\n",
    "from collections import Counter\n",
    "from torchvision import datasets\n",
    "from torchvision import transforms\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "\n",
    "train_dataset = datasets.MNIST(\n",
    "    root=\"./data\", train=True, transform=transforms.ToTensor(), download=True\n",
    ")\n",
    "\n",
    "train_loader = DataLoader(\n",
    "    dataset=train_dataset,\n",
    "    batch_size=BATCH_SIZE,\n",
    "    num_workers=NUM_WORKERS,\n",
    "    drop_last=True,\n",
    "    shuffle=True,\n",
    ")\n",
    "\n",
    "test_dataset = datasets.MNIST(\n",
    "    root=\"./data\", train=False, transform=transforms.ToTensor()\n",
    ")\n",
    "\n",
    "test_loader = DataLoader(\n",
    "    dataset=test_dataset,\n",
    "    batch_size=BATCH_SIZE,\n",
    "    num_workers=NUM_WORKERS,\n",
    "    drop_last=False,\n",
    "    shuffle=False,\n",
    ")\n",
    "\n",
    "train_counter = Counter()\n",
    "for images, labels in train_loader:\n",
    "    train_counter.update(labels.tolist())\n",
    "\n",
    "test_counter = Counter()\n",
    "for images, labels in test_loader:\n",
    "    test_counter.update(labels.tolist())\n",
    "\n",
    "print(\"\\nTraining label distribution:\")\n",
    "sorted(train_counter.items())\n",
    "\n",
    "print(\"\\nTest label distribution:\")\n",
    "sorted(test_counter.items())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06f8b3ab",
   "metadata": {},
   "source": [
    "### Performance baseline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48152108",
   "metadata": {},
   "source": [
    "- Especially for imbalanced datasets, it's pretty helpful to compute a performance baseline.\n",
    "- In classification contexts, a useful baseline is to compute the accuracy for a scenario where the model always predicts the majority class -- we want our model to be better than that!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "2964f21c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Majority class: 1\n",
      "Accuracy when always predicting the majority class:\n",
      "0.11 (11.35%)\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 8;\n",
       "                var nbb_unformatted_code = \"# %load ../code_dataset/performance_baseline.py\\nmajority_class = test_counter.most_common(1)[0]\\nprint(\\\"Majority class:\\\", majority_class[0])\\n\\nbaseline_acc = majority_class[1] / sum(test_counter.values())\\nprint(\\\"Accuracy when always predicting the majority class:\\\")\\nprint(f\\\"{baseline_acc:.2f} ({baseline_acc*100:.2f}%)\\\")\";\n",
       "                var nbb_formatted_code = \"# %load ../code_dataset/performance_baseline.py\\nmajority_class = test_counter.most_common(1)[0]\\nprint(\\\"Majority class:\\\", majority_class[0])\\n\\nbaseline_acc = majority_class[1] / sum(test_counter.values())\\nprint(\\\"Accuracy when always predicting the majority class:\\\")\\nprint(f\\\"{baseline_acc:.2f} ({baseline_acc*100:.2f}%)\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_dataset/performance_baseline.py\n",
    "majority_class = test_counter.most_common(1)[0]\n",
    "print(\"Majority class:\", majority_class[0])\n",
    "\n",
    "baseline_acc = majority_class[1] / sum(test_counter.values())\n",
    "print(\"Accuracy when always predicting the majority class:\")\n",
    "print(f\"{baseline_acc:.2f} ({baseline_acc*100:.2f}%)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a65b93d9",
   "metadata": {},
   "source": [
    "## A quick visual check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "208eba1a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1: E999 SyntaxError: invalid syntax\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 9;\n",
       "                var nbb_unformatted_code = \"# %load ../code_dataset/plot_visual-check_basic.py\\n%matplotlib inline\\nimport matplotlib.pyplot as plt\\nimport numpy as np\\nimport torchvision\\n\\n\\nfor images, labels in train_loader:  \\n    break\\n\\nplt.figure(figsize=(8, 8))\\nplt.axis(\\\"off\\\")\\nplt.title(\\\"Training images\\\")\\nplt.imshow(np.transpose(torchvision.utils.make_grid(\\n    images[:64], \\n    padding=2,\\n    normalize=True),\\n    (1, 2, 0)))\\nplt.show()\";\n",
       "                var nbb_formatted_code = \"# %load ../code_dataset/plot_visual-check_basic.py\\n%matplotlib inline\\nimport matplotlib.pyplot as plt\\nimport numpy as np\\nimport torchvision\\n\\n\\nfor images, labels in train_loader:\\n    break\\n\\nplt.figure(figsize=(8, 8))\\nplt.axis(\\\"off\\\")\\nplt.title(\\\"Training images\\\")\\nplt.imshow(\\n    np.transpose(\\n        torchvision.utils.make_grid(images[:64], padding=2, normalize=True), (1, 2, 0)\\n    )\\n)\\nplt.show()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_dataset/plot_visual-check_basic.py\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torchvision\n",
    "\n",
    "\n",
    "for images, labels in train_loader:  \n",
    "    break\n",
    "\n",
    "plt.figure(figsize=(8, 8))\n",
    "plt.axis(\"off\")\n",
    "plt.title(\"Training images\")\n",
    "plt.imshow(np.transpose(torchvision.utils.make_grid(\n",
    "    images[:64], \n",
    "    padding=2,\n",
    "    normalize=True),\n",
    "    (1, 2, 0)))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c96452f",
   "metadata": {},
   "source": [
    "### Setting up a `DataModule`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c565e9f",
   "metadata": {},
   "source": [
    "- There are three main ways we can prepare the dataset for Lightning. We can\n",
    "  1. make the dataset part of the model;\n",
    "  2. set up the data loaders as usual and feed them to the fit method of a Lightning Trainer -- the Trainer is introduced in the following subsection;\n",
    "  3. create a LightningDataModule.\n",
    "- Here, we will use approach 3, which is the most organized approach. The `LightningDataModule` consists of several self-explanatory methods, as we can see below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "95064321",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 10;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/datamodule_mnist_basic.py\\nfrom torch.utils.data.dataset import random_split\\n\\n\\nclass DataModule(pl.LightningDataModule):\\n    def __init__(self, data_path=\\\"./\\\"):\\n        super().__init__()\\n        self.data_path = data_path\\n\\n    def prepare_data(self):\\n        datasets.MNIST(root=self.data_path, download=True)\\n        return\\n\\n    def setup(self, stage=None):\\n        # Note transforms.ToTensor() scales input images\\n        # to 0-1 range\\n        train = datasets.MNIST(\\n            root=self.data_path,\\n            train=True,\\n            transform=transforms.ToTensor(),\\n            download=False,\\n        )\\n\\n        self.test = datasets.MNIST(\\n            root=self.data_path,\\n            train=False,\\n            transform=transforms.ToTensor(),\\n            download=False,\\n        )\\n\\n        self.train, self.valid = random_split(train, lengths=[55000, 5000])\\n\\n    def train_dataloader(self):\\n        train_loader = DataLoader(\\n            dataset=self.train,\\n            batch_size=BATCH_SIZE,\\n            drop_last=True,\\n            shuffle=True,\\n            num_workers=NUM_WORKERS,\\n        )\\n        return train_loader\\n\\n    def val_dataloader(self):\\n        valid_loader = DataLoader(\\n            dataset=self.valid,\\n            batch_size=BATCH_SIZE,\\n            drop_last=False,\\n            shuffle=False,\\n            num_workers=NUM_WORKERS,\\n        )\\n        return valid_loader\\n\\n    def test_dataloader(self):\\n        test_loader = DataLoader(\\n            dataset=self.test,\\n            batch_size=BATCH_SIZE,\\n            drop_last=False,\\n            shuffle=False,\\n            num_workers=NUM_WORKERS,\\n        )\\n        return test_loader\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/datamodule_mnist_basic.py\\nfrom torch.utils.data.dataset import random_split\\n\\n\\nclass DataModule(pl.LightningDataModule):\\n    def __init__(self, data_path=\\\"./\\\"):\\n        super().__init__()\\n        self.data_path = data_path\\n\\n    def prepare_data(self):\\n        datasets.MNIST(root=self.data_path, download=True)\\n        return\\n\\n    def setup(self, stage=None):\\n        # Note transforms.ToTensor() scales input images\\n        # to 0-1 range\\n        train = datasets.MNIST(\\n            root=self.data_path,\\n            train=True,\\n            transform=transforms.ToTensor(),\\n            download=False,\\n        )\\n\\n        self.test = datasets.MNIST(\\n            root=self.data_path,\\n            train=False,\\n            transform=transforms.ToTensor(),\\n            download=False,\\n        )\\n\\n        self.train, self.valid = random_split(train, lengths=[55000, 5000])\\n\\n    def train_dataloader(self):\\n        train_loader = DataLoader(\\n            dataset=self.train,\\n            batch_size=BATCH_SIZE,\\n            drop_last=True,\\n            shuffle=True,\\n            num_workers=NUM_WORKERS,\\n        )\\n        return train_loader\\n\\n    def val_dataloader(self):\\n        valid_loader = DataLoader(\\n            dataset=self.valid,\\n            batch_size=BATCH_SIZE,\\n            drop_last=False,\\n            shuffle=False,\\n            num_workers=NUM_WORKERS,\\n        )\\n        return valid_loader\\n\\n    def test_dataloader(self):\\n        test_loader = DataLoader(\\n            dataset=self.test,\\n            batch_size=BATCH_SIZE,\\n            drop_last=False,\\n            shuffle=False,\\n            num_workers=NUM_WORKERS,\\n        )\\n        return test_loader\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_lightningmodule/datamodule_mnist_basic.py\n",
    "from torch.utils.data.dataset import random_split\n",
    "\n",
    "\n",
    "class DataModule(pl.LightningDataModule):\n",
    "    def __init__(self, data_path=\"./\"):\n",
    "        super().__init__()\n",
    "        self.data_path = data_path\n",
    "\n",
    "    def prepare_data(self):\n",
    "        datasets.MNIST(root=self.data_path, download=True)\n",
    "        return\n",
    "\n",
    "    def setup(self, stage=None):\n",
    "        # Note transforms.ToTensor() scales input images\n",
    "        # to 0-1 range\n",
    "        train = datasets.MNIST(\n",
    "            root=self.data_path,\n",
    "            train=True,\n",
    "            transform=transforms.ToTensor(),\n",
    "            download=False,\n",
    "        )\n",
    "\n",
    "        self.test = datasets.MNIST(\n",
    "            root=self.data_path,\n",
    "            train=False,\n",
    "            transform=transforms.ToTensor(),\n",
    "            download=False,\n",
    "        )\n",
    "\n",
    "        self.train, self.valid = random_split(train, lengths=[55000, 5000])\n",
    "\n",
    "    def train_dataloader(self):\n",
    "        train_loader = DataLoader(\n",
    "            dataset=self.train,\n",
    "            batch_size=BATCH_SIZE,\n",
    "            drop_last=True,\n",
    "            shuffle=True,\n",
    "            num_workers=NUM_WORKERS,\n",
    "        )\n",
    "        return train_loader\n",
    "\n",
    "    def val_dataloader(self):\n",
    "        valid_loader = DataLoader(\n",
    "            dataset=self.valid,\n",
    "            batch_size=BATCH_SIZE,\n",
    "            drop_last=False,\n",
    "            shuffle=False,\n",
    "            num_workers=NUM_WORKERS,\n",
    "        )\n",
    "        return valid_loader\n",
    "\n",
    "    def test_dataloader(self):\n",
    "        test_loader = DataLoader(\n",
    "            dataset=self.test,\n",
    "            batch_size=BATCH_SIZE,\n",
    "            drop_last=False,\n",
    "            shuffle=False,\n",
    "            num_workers=NUM_WORKERS,\n",
    "        )\n",
    "        return test_loader\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34182855",
   "metadata": {},
   "source": [
    "- Note that the `prepare_data` method is usually used for steps that only need to be executed once, for example, downloading the dataset; the `setup` method defines the dataset loading -- if we run our code in a distributed setting, this will be called on each node / GPU. \n",
    "- Next, let's initialize the `DataModule`; we use a random seed for reproducibility (so that the data set is shuffled the same way when we re-execute this code):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "47bd719f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 11;\n",
       "                var nbb_unformatted_code = \"torch.manual_seed(1) \\ndata_module = DataModule(data_path='./data')\";\n",
       "                var nbb_formatted_code = \"torch.manual_seed(1)\\ndata_module = DataModule(data_path=\\\"./data\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "torch.manual_seed(1) \n",
    "data_module = DataModule(data_path='./data')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d19674fd",
   "metadata": {},
   "source": [
    "## Training the model using the PyTorch Lightning Trainer class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f4e3ffd",
   "metadata": {},
   "source": [
    "- Next, we initialize our model.\n",
    "- Also, we define a call back to obtain the model with the best validation set performance after training.\n",
    "- PyTorch Lightning offers [many advanced logging services](https://pytorch-lightning.readthedocs.io/en/latest/extensions/logging.html) like Weights & Biases. However, here, we will keep things simple and use the `CSVLogger`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d555825a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 12;\n",
       "                var nbb_unformatted_code = \"pytorch_model = PyTorchModel(\\n    input_size=28*28,\\n    hidden_units=HIDDEN_UNITS,\\n    dropout_proba=0.5,\\n    num_classes=10\\n)\";\n",
       "                var nbb_formatted_code = \"pytorch_model = PyTorchModel(\\n    input_size=28 * 28, hidden_units=HIDDEN_UNITS, dropout_proba=0.5, num_classes=10\\n)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pytorch_model = PyTorchModel(\n",
    "    input_size=28*28,\n",
    "    hidden_units=HIDDEN_UNITS,\n",
    "    dropout_proba=0.5,\n",
    "    num_classes=10\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "598f6194",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 13;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/logger_csv_acc_basic.py\\nfrom pytorch_lightning.callbacks import ModelCheckpoint\\nfrom pytorch_lightning.loggers import CSVLogger\\n\\n\\nlightning_model = LightningModel(pytorch_model, learning_rate=LEARNING_RATE)\\n\\ncallbacks = [\\n    ModelCheckpoint(\\n        save_top_k=1, mode=\\\"max\\\", monitor=\\\"valid_acc\\\"\\n    )  # save top 1 model\\n]\\nlogger = CSVLogger(save_dir=\\\"logs/\\\", name=\\\"my-model\\\")\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/logger_csv_acc_basic.py\\nfrom pytorch_lightning.callbacks import ModelCheckpoint\\nfrom pytorch_lightning.loggers import CSVLogger\\n\\n\\nlightning_model = LightningModel(pytorch_model, learning_rate=LEARNING_RATE)\\n\\ncallbacks = [\\n    ModelCheckpoint(save_top_k=1, mode=\\\"max\\\", monitor=\\\"valid_acc\\\")  # save top 1 model\\n]\\nlogger = CSVLogger(save_dir=\\\"logs/\\\", name=\\\"my-model\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_lightningmodule/logger_csv_acc_basic.py\n",
    "from pytorch_lightning.callbacks import ModelCheckpoint\n",
    "from pytorch_lightning.loggers import CSVLogger\n",
    "\n",
    "\n",
    "lightning_model = LightningModel(pytorch_model, learning_rate=LEARNING_RATE)\n",
    "\n",
    "callbacks = [\n",
    "    ModelCheckpoint(\n",
    "        save_top_k=1, mode=\"max\", monitor=\"valid_acc\"\n",
    "    )  # save top 1 model\n",
    "]\n",
    "logger = CSVLogger(save_dir=\"logs/\", name=\"my-model\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65b36418",
   "metadata": {},
   "source": [
    "- Now it's time to train our model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "1b4154cd",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/jovyan/conda/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/callback_connector.py:90: LightningDeprecationWarning: Setting `Trainer(progress_bar_refresh_rate=50)` is deprecated in v1.5 and will be removed in v1.7. Please pass `pytorch_lightning.callbacks.progress.TQDMProgressBar` with `refresh_rate` directly to the Trainer's `callbacks` argument instead. Or, to disable the progress bar pass `enable_progress_bar = False` to the Trainer.\n",
      "  rank_zero_deprecation(\n",
      "GPU available: True, used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "\n",
      "  | Name      | Type         | Params\n",
      "-------------------------------------------\n",
      "0 | model     | PyTorchModel | 136 K \n",
      "1 | train_acc | Accuracy     | 0     \n",
      "2 | valid_acc | Accuracy     | 0     \n",
      "3 | test_acc  | Accuracy     | 0     \n",
      "-------------------------------------------\n",
      "136 K     Trainable params\n",
      "0         Non-trainable params\n",
      "136 K     Total params\n",
      "0.544     Total estimated model params size (MB)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a7042cc7ac564deab2f9232bc13319d9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation sanity check: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9d57e2b0fc284593a90543130eaa3c04",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training took 1.47 min in total.\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 14;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/trainer_nb_basic.py\\nimport time\\n\\n\\ntrainer = pl.Trainer(\\n    max_epochs=NUM_EPOCHS,\\n    callbacks=callbacks,\\n    progress_bar_refresh_rate=50,  # recommended for notebooks\\n    accelerator=\\\"auto\\\",  # Uses GPUs or TPUs if available\\n    devices=\\\"auto\\\",  # Uses all available GPUs/TPUs if applicable\\n    logger=logger,\\n    deterministic=True,\\n    log_every_n_steps=10,\\n)\\n\\nstart_time = time.time()\\ntrainer.fit(model=lightning_model, datamodule=data_module)\\n\\nruntime = (time.time() - start_time) / 60\\nprint(f\\\"Training took {runtime:.2f} min in total.\\\")\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/trainer_nb_basic.py\\nimport time\\n\\n\\ntrainer = pl.Trainer(\\n    max_epochs=NUM_EPOCHS,\\n    callbacks=callbacks,\\n    progress_bar_refresh_rate=50,  # recommended for notebooks\\n    accelerator=\\\"auto\\\",  # Uses GPUs or TPUs if available\\n    devices=\\\"auto\\\",  # Uses all available GPUs/TPUs if applicable\\n    logger=logger,\\n    deterministic=True,\\n    log_every_n_steps=10,\\n)\\n\\nstart_time = time.time()\\ntrainer.fit(model=lightning_model, datamodule=data_module)\\n\\nruntime = (time.time() - start_time) / 60\\nprint(f\\\"Training took {runtime:.2f} min in total.\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_lightningmodule/trainer_nb_basic.py\n",
    "import time\n",
    "\n",
    "\n",
    "trainer = pl.Trainer(\n",
    "    max_epochs=NUM_EPOCHS,\n",
    "    callbacks=callbacks,\n",
    "    progress_bar_refresh_rate=50,  # recommended for notebooks\n",
    "    accelerator=\"auto\",  # Uses GPUs or TPUs if available\n",
    "    devices=\"auto\",  # Uses all available GPUs/TPUs if applicable\n",
    "    logger=logger,\n",
    "    deterministic=True,\n",
    "    log_every_n_steps=10,\n",
    ")\n",
    "\n",
    "start_time = time.time()\n",
    "trainer.fit(model=lightning_model, datamodule=data_module)\n",
    "\n",
    "runtime = (time.time() - start_time) / 60\n",
    "print(f\"Training took {runtime:.2f} min in total.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a1d6022",
   "metadata": {},
   "source": [
    "## Evaluating the model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41053fb4",
   "metadata": {},
   "source": [
    "- After training, let's plot our training ACC and validation ACC using pandas, which, in turn, uses matplotlib for plotting (PS: you may want to check out [more advanced logger](https://pytorch-lightning.readthedocs.io/en/latest/extensions/logging.html) later on, which take care of it for us):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c3a243bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 15;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/logger_csv_plot_basic.py\\nimport pandas as pd\\nimport matplotlib.pyplot as plt\\n\\n\\nmetrics = pd.read_csv(f\\\"{trainer.logger.log_dir}/metrics.csv\\\")\\n\\naggreg_metrics = []\\nagg_col = \\\"epoch\\\"\\nfor i, dfg in metrics.groupby(agg_col):\\n    agg = dict(dfg.mean())\\n    agg[agg_col] = i\\n    aggreg_metrics.append(agg)\\n\\ndf_metrics = pd.DataFrame(aggreg_metrics)\\ndf_metrics[[\\\"train_loss\\\", \\\"valid_loss\\\"]].plot(\\n    grid=True, legend=True, xlabel=\\\"Epoch\\\", ylabel=\\\"Loss\\\"\\n)\\ndf_metrics[[\\\"train_acc\\\", \\\"valid_acc\\\"]].plot(\\n    grid=True, legend=True, xlabel=\\\"Epoch\\\", ylabel=\\\"ACC\\\"\\n)\\n\\nplt.show()\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/logger_csv_plot_basic.py\\nimport pandas as pd\\nimport matplotlib.pyplot as plt\\n\\n\\nmetrics = pd.read_csv(f\\\"{trainer.logger.log_dir}/metrics.csv\\\")\\n\\naggreg_metrics = []\\nagg_col = \\\"epoch\\\"\\nfor i, dfg in metrics.groupby(agg_col):\\n    agg = dict(dfg.mean())\\n    agg[agg_col] = i\\n    aggreg_metrics.append(agg)\\n\\ndf_metrics = pd.DataFrame(aggreg_metrics)\\ndf_metrics[[\\\"train_loss\\\", \\\"valid_loss\\\"]].plot(\\n    grid=True, legend=True, xlabel=\\\"Epoch\\\", ylabel=\\\"Loss\\\"\\n)\\ndf_metrics[[\\\"train_acc\\\", \\\"valid_acc\\\"]].plot(\\n    grid=True, legend=True, xlabel=\\\"Epoch\\\", ylabel=\\\"ACC\\\"\\n)\\n\\nplt.show()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_lightningmodule/logger_csv_plot_basic.py\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "metrics = pd.read_csv(f\"{trainer.logger.log_dir}/metrics.csv\")\n",
    "\n",
    "aggreg_metrics = []\n",
    "agg_col = \"epoch\"\n",
    "for i, dfg in metrics.groupby(agg_col):\n",
    "    agg = dict(dfg.mean())\n",
    "    agg[agg_col] = i\n",
    "    aggreg_metrics.append(agg)\n",
    "\n",
    "df_metrics = pd.DataFrame(aggreg_metrics)\n",
    "df_metrics[[\"train_loss\", \"valid_loss\"]].plot(\n",
    "    grid=True, legend=True, xlabel=\"Epoch\", ylabel=\"Loss\"\n",
    ")\n",
    "df_metrics[[\"train_acc\", \"valid_acc\"]].plot(\n",
    "    grid=True, legend=True, xlabel=\"Epoch\", ylabel=\"ACC\"\n",
    ")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5d6b9a5",
   "metadata": {},
   "source": [
    "- The `trainer` automatically saves the model with the best validation accuracy automatically for us, we which we can load from the checkpoint via the `ckpt_path='best'` argument; below we use the `trainer` instance to evaluate the best model on the test set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "a12ebfdb",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Restoring states from the checkpoint path at logs/my-model/version_26/checkpoints/epoch=4-step=1069.ckpt\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "Loaded model weights from checkpoint at logs/my-model/version_26/checkpoints/epoch=4-step=1069.ckpt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "284c0189c5194292bc96188a73332ec6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing: 0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------\n",
      "DATALOADER:0 TEST RESULTS\n",
      "{'test_acc': 0.9678000211715698}\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[{'test_acc': 0.9678000211715698}]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 16;\n",
       "                var nbb_unformatted_code = \"trainer.test(model=lightning_model, datamodule=data_module, ckpt_path='best')\";\n",
       "                var nbb_formatted_code = \"trainer.test(model=lightning_model, datamodule=data_module, ckpt_path=\\\"best\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "trainer.test(model=lightning_model, datamodule=data_module, ckpt_path='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ad02490",
   "metadata": {},
   "source": [
    "## Predicting labels of new data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2c99c9f",
   "metadata": {},
   "source": [
    "- We can use the `trainer.predict` method either on a new `DataLoader` (`trainer.predict(dataloaders=...)`) or `DataModule` (`trainer.predict(datamodule=...)`) to apply the model to new data.\n",
    "- Alternatively, we can also manually load the best model from a checkpoint as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "888d7401",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "logs/my-model/version_26/checkpoints/epoch=4-step=1069.ckpt\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 17;\n",
       "                var nbb_unformatted_code = \"path = trainer.checkpoint_callback.best_model_path\\nprint(path)\";\n",
       "                var nbb_formatted_code = \"path = trainer.checkpoint_callback.best_model_path\\nprint(path)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "path = trainer.checkpoint_callback.best_model_path\n",
    "print(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a20a392d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 18;\n",
       "                var nbb_unformatted_code = \"lightning_model = LightningModel.load_from_checkpoint(path, model=pytorch_model)\\nlightning_model.eval();\";\n",
       "                var nbb_formatted_code = \"lightning_model = LightningModel.load_from_checkpoint(path, model=pytorch_model)\\nlightning_model.eval()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "lightning_model = LightningModel.load_from_checkpoint(path, model=pytorch_model)\n",
    "lightning_model.eval();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ef39e66",
   "metadata": {},
   "source": [
    "- For simplicity, we reused our existing `pytorch_model` above. However, we could also reinitialize the `pytorch_model`, and the `.load_from_checkpoint` method would load the corresponding model weights for us from the checkpoint file.\n",
    "- Now, below is an example applying the model manually. Here, pretend that the `test_dataloader` is a new data loader."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "1d52a91b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 19;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/datamodule_testloader.py\\ntest_dataloader = data_module.test_dataloader()\\nacc = torchmetrics.Accuracy()\\n\\nfor batch in test_dataloader:\\n    features, true_labels = batch\\n\\n    with torch.no_grad():\\n        logits = lightning_model(features)\\n\\n    predicted_labels = torch.argmax(logits, dim=1)\\n    acc(predicted_labels, true_labels)\\n\\npredicted_labels[:5]\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/datamodule_testloader.py\\ntest_dataloader = data_module.test_dataloader()\\nacc = torchmetrics.Accuracy()\\n\\nfor batch in test_dataloader:\\n    features, true_labels = batch\\n\\n    with torch.no_grad():\\n        logits = lightning_model(features)\\n\\n    predicted_labels = torch.argmax(logits, dim=1)\\n    acc(predicted_labels, true_labels)\\n\\npredicted_labels[:5]\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_lightningmodule/datamodule_testloader.py\n",
    "test_dataloader = data_module.test_dataloader()\n",
    "acc = torchmetrics.Accuracy()\n",
    "\n",
    "for batch in test_dataloader:\n",
    "    features, true_labels = batch\n",
    "\n",
    "    with torch.no_grad():\n",
    "        logits = lightning_model(features)\n",
    "\n",
    "    predicted_labels = torch.argmax(logits, dim=1)\n",
    "    acc(predicted_labels, true_labels)\n",
    "\n",
    "predicted_labels[:5]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4135ecc0",
   "metadata": {},
   "source": [
    "- As an internal check, if the model was loaded correctly, the test accuracy below should be identical to the test accuracy we saw earlier in the previous section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "6f21a4dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy: 0.9678 (96.78%)\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 20;\n",
       "                var nbb_unformatted_code = \"test_acc = acc.compute()\\nprint(f'Test accuracy: {test_acc:.4f} ({test_acc*100:.2f}%)')\";\n",
       "                var nbb_formatted_code = \"test_acc = acc.compute()\\nprint(f\\\"Test accuracy: {test_acc:.4f} ({test_acc*100:.2f}%)\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_acc = acc.compute()\n",
    "print(f'Test accuracy: {test_acc:.4f} ({test_acc*100:.2f}%)')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e117f2b8",
   "metadata": {},
   "source": [
    "## Inspecting Failure Cases"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "936812ae",
   "metadata": {},
   "source": [
    "- In practice, it is often informative to look at failure cases like wrong predictions for particular training instances as it can give us some insights into the model behavior and dataset.\n",
    "- Inspecting failure cases can sometimes reveal interesting patterns and even highlight dataset and labeling issues."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "ca72a754",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 21;\n",
       "                var nbb_unformatted_code = \"# In the case of MNIST, the class label mapping\\n# is relatively trivial\\nclass_dict = {0: 'digit 0',\\n              1: 'digit 1',\\n              2: 'digit 2',\\n              3: 'digit 3',\\n              4: 'digit 4',\\n              5: 'digit 5',\\n              6: 'digit 6',\\n              7: 'digit 7',\\n              8: 'digit 8',\\n              9: 'digit 9'}\";\n",
       "                var nbb_formatted_code = \"# In the case of MNIST, the class label mapping\\n# is relatively trivial\\nclass_dict = {\\n    0: \\\"digit 0\\\",\\n    1: \\\"digit 1\\\",\\n    2: \\\"digit 2\\\",\\n    3: \\\"digit 3\\\",\\n    4: \\\"digit 4\\\",\\n    5: \\\"digit 5\\\",\\n    6: \\\"digit 6\\\",\\n    7: \\\"digit 7\\\",\\n    8: \\\"digit 8\\\",\\n    9: \\\"digit 9\\\",\\n}\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# In the case of MNIST, the class label mapping\n",
    "# is relatively trivial\n",
    "class_dict = {0: 'digit 0',\n",
    "              1: 'digit 1',\n",
    "              2: 'digit 2',\n",
    "              3: 'digit 3',\n",
    "              4: 'digit 4',\n",
    "              5: 'digit 5',\n",
    "              6: 'digit 6',\n",
    "              7: 'digit 7',\n",
    "              8: 'digit 8',\n",
    "              9: 'digit 9'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "a68d8b92",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 15 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 22;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/plot_failurecases_basic.py\\n# Append the folder that contains the\\n# helper_data.py, helper_plotting.py, and helper_evaluate.py\\n# files so we can import from them\\n\\nimport sys\\n\\nsys.path.append(\\\"../../pytorch_ipynb\\\")\\n\\nfrom helper_plotting import show_examples\\n\\n\\nshow_examples(\\n    model=lightning_model, data_loader=test_dataloader, class_dict=class_dict\\n)\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/plot_failurecases_basic.py\\n# Append the folder that contains the\\n# helper_data.py, helper_plotting.py, and helper_evaluate.py\\n# files so we can import from them\\n\\nimport sys\\n\\nsys.path.append(\\\"../../pytorch_ipynb\\\")\\n\\nfrom helper_plotting import show_examples\\n\\n\\nshow_examples(model=lightning_model, data_loader=test_dataloader, class_dict=class_dict)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_lightningmodule/plot_failurecases_basic.py\n",
    "# Append the folder that contains the\n",
    "# helper_data.py, helper_plotting.py, and helper_evaluate.py\n",
    "# files so we can import from them\n",
    "\n",
    "import sys\n",
    "\n",
    "sys.path.append(\"../../pytorch_ipynb\")\n",
    "\n",
    "from helper_plotting import show_examples\n",
    "\n",
    "\n",
    "show_examples(\n",
    "    model=lightning_model, data_loader=test_dataloader, class_dict=class_dict\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4eb65020",
   "metadata": {},
   "source": [
    "- In addition to inspecting failure cases visually, it is also informative to look at which classes the model confuses the most via a confusion matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "3612be2a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 23;\n",
       "                var nbb_unformatted_code = \"# %load ../code_lightningmodule/plot_confusion-matrix_basic.py\\nfrom torchmetrics import ConfusionMatrix\\nimport matplotlib\\nfrom mlxtend.plotting import plot_confusion_matrix\\n\\n\\ncmat = ConfusionMatrix(num_classes=len(class_dict))\\n\\nfor x, y in test_dataloader:\\n\\n    with torch.no_grad():\\n        pred = lightning_model(x)\\n    cmat(pred, y)\\n\\ncmat_tensor = cmat.compute()\\ncmat = cmat_tensor.numpy()\\n\\nfig, ax = plot_confusion_matrix(\\n    conf_mat=cmat,\\n    class_names=class_dict.values(),\\n    norm_colormap=matplotlib.colors.LogNorm()  \\n    # normed colormaps highlight the off-diagonals \\n    # for high-accuracy models better\\n)\\n\\nplt.show()\";\n",
       "                var nbb_formatted_code = \"# %load ../code_lightningmodule/plot_confusion-matrix_basic.py\\nfrom torchmetrics import ConfusionMatrix\\nimport matplotlib\\nfrom mlxtend.plotting import plot_confusion_matrix\\n\\n\\ncmat = ConfusionMatrix(num_classes=len(class_dict))\\n\\nfor x, y in test_dataloader:\\n\\n    with torch.no_grad():\\n        pred = lightning_model(x)\\n    cmat(pred, y)\\n\\ncmat_tensor = cmat.compute()\\ncmat = cmat_tensor.numpy()\\n\\nfig, ax = plot_confusion_matrix(\\n    conf_mat=cmat,\\n    class_names=class_dict.values(),\\n    norm_colormap=matplotlib.colors.LogNorm()\\n    # normed colormaps highlight the off-diagonals\\n    # for high-accuracy models better\\n)\\n\\nplt.show()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# %load ../code_lightningmodule/plot_confusion-matrix_basic.py\n",
    "from torchmetrics import ConfusionMatrix\n",
    "import matplotlib\n",
    "from mlxtend.plotting import plot_confusion_matrix\n",
    "\n",
    "\n",
    "cmat = ConfusionMatrix(num_classes=len(class_dict))\n",
    "\n",
    "for x, y in test_dataloader:\n",
    "\n",
    "    with torch.no_grad():\n",
    "        pred = lightning_model(x)\n",
    "    cmat(pred, y)\n",
    "\n",
    "cmat_tensor = cmat.compute()\n",
    "cmat = cmat_tensor.numpy()\n",
    "\n",
    "fig, ax = plot_confusion_matrix(\n",
    "    conf_mat=cmat,\n",
    "    class_names=class_dict.values(),\n",
    "    norm_colormap=matplotlib.colors.LogNorm()  \n",
    "    # normed colormaps highlight the off-diagonals \n",
    "    # for high-accuracy models better\n",
    ")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9ed5403b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pytorch_lightning: 1.5.1\n",
      "torchvision      : 0.11.2\n",
      "matplotlib       : 3.3.4\n",
      "torchmetrics     : 0.6.2\n",
      "numpy            : 1.22.0\n",
      "sys              : 3.8.12 | packaged by conda-forge | (default, Oct 12 2021, 21:59:51) \n",
      "[GCC 9.4.0]\n",
      "pandas           : 1.4.1\n",
      "torch            : 1.10.1\n",
      "\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 24;\n",
       "                var nbb_unformatted_code = \"%watermark --iversions\";\n",
       "                var nbb_formatted_code = \"%watermark --iversions\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%watermark --iversions"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
